home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 February / PCWorld_2008-02_cd.bin / audio-video / reaper / reaper2028-install.exe / Effects / Till / Transient-driven Auto-Pan v1.1 (Slave) < prev   
Text File  |  2007-12-03  |  4KB  |  197 lines
  1. // written by Till
  2. //
  3. // note: the effect receives data from reg[x] x is specified by the "receive pan data from" slider
  4. //
  5. // note: the lookahead must be compensated manually in REAPER versions < 2
  6. //
  7. // note: the frequency of data being received from the master depends on
  8. // the overall blocksize which is apparently depending on your interface's latency.
  9. // so the slave effect cannot always be up to date with the master effect
  10. // the quantisation is being interpolated linearly
  11.  
  12. desc: Transient-driven Auto-Pan (Slave)
  13. slider1:0<0,2,1{Stereo,Left,Right}>Input
  14. slider2:0<0,9,1{reg00,reg01,reg02,reg03,reg04,reg05,reg06,reg07,reg08,reg09}>Receive Pan data from
  15. slider3:0<-100,100,1>Received Pan
  16. slider4:0<0,10,1>Sloppiness
  17. slider5:0<0,1,1{No,Yes}>Invert received Pan
  18. slider6:1<.2,5,.1>Multiply received Pan by
  19. slider7:100<1,100,1>Max. Pan
  20. slider8:0<0,10,1>Max Delay (ms)
  21. slider9:0<0,100,1>Look-ahead (ms)
  22. slider10:0<-100,100,1>Current Pan
  23.  
  24.  
  25. /////////////////
  26. ///           ///
  27. ///  I N I T  ///
  28. ///           ///
  29. /////////////////
  30.  
  31. @init
  32.  
  33.     log2 = log(2);
  34.     sqrt2 = sqrt(2);
  35.  
  36.     curpan = 0;
  37.  
  38.     maxdelay = ceil((10 + 100) / 1000 * srate);
  39.  
  40.     delaybufferl = 0;
  41.     delaybufferr = 2 * maxdelay;
  42.  
  43.     delaypointer = 0;
  44.  
  45.     receivedpan = 0;
  46.     oldreceivedpan = 0;
  47.  
  48.     spls = 0;
  49.  
  50.     pdc_bot_ch = 0;
  51.     pdc_top_ch = 2;
  52.  
  53. /////////////////
  54. ///           ///
  55. ///  SLIDER   ///
  56. ///           ///
  57. /////////////////
  58.  
  59. @slider
  60.  
  61.     // SLIDER VALUES
  62.  
  63.     input = slider1;
  64.  
  65.     receive = slider2;
  66.  
  67.     sloppiness = slider4;
  68.  
  69.     invert = slider5;
  70.  
  71.     multiply = slider6;
  72.  
  73.     maxpan = slider7;
  74.  
  75.     delay = slider8 / 1000 * srate;
  76.  
  77.     lookahead = slider9 / 1000 * srate;
  78.  
  79.     pdc_delay = lookahead;
  80.  
  81. /////////////////
  82. ///           ///
  83. ///  BLOCK    ///
  84. ///           ///
  85. /////////////////
  86.  
  87. @block
  88.  
  89.     blocksize = samplesblock;
  90.  
  91. // receiving
  92.  
  93.     oldreceivedpan = receivedpan;
  94.  
  95.     receive == 0 ? (
  96.         receivedpan = reg00;
  97.     ) : receive == 1 ? (
  98.         receivedpan = reg01;
  99.     ) : receive == 2 ? (
  100.         receivedpan = reg02;
  101.     ) : receive == 3 ? (
  102.         receivedpan = reg03;
  103.     ) : receive == 4 ? (
  104.         receivedpan = reg04;
  105.     ) : receive == 5 ? (
  106.         receivedpan = reg5;
  107.     ) : receive == 6 ? (
  108.         receivedpan = reg6;
  109.     ) : receive == 7 ? (
  110.         receivedpan = reg7;
  111.     ) : receive == 8 ? (
  112.         receivedpan = reg8;
  113.     ) : receive == 9 ? (
  114.         receivedpan = reg09;
  115.     ) : 0;
  116.  
  117.     slider3 = receivedpan;
  118.  
  119.     spls = 0;
  120.  
  121. /////////////////
  122. ///           ///
  123. ///  SAMPLE   ///
  124. ///           ///
  125. /////////////////
  126.  
  127. @sample
  128.  
  129. // choosing input
  130.  
  131.     input == 0 ? (
  132.         l = spl0;
  133.         r = spl1;
  134.     ) : input == 1 ? (
  135.         l = spl0;
  136.         r = spl0;
  137.     ) : input == 2 ? (
  138.         l = spl1;
  139.         r = spl1;
  140.     ) : 0;
  141.  
  142. // buffering
  143.  
  144.     delaybufferl[delaypointer] = l;
  145.     delaybufferl[delaypointer + maxdelay] = l;
  146.     delaybufferr[delaypointer] = r;
  147.     delaybufferr[delaypointer + maxdelay] = r;
  148.  
  149. // interpolating receivedpan
  150.  
  151.     curpan = oldreceivedpan + (receivedpan - oldreceivedpan) * spls / blocksize;
  152.  
  153. // modifying input pan
  154.  
  155.     invert && curpan *= -1;
  156.     curpan *= multiply;
  157.     curpan = min(max(-maxpan, curpan), maxpan);
  158.  
  159. // sloppiness
  160.  
  161.     s = sloppiness * sloppiness * sloppiness * sloppiness;
  162.     curpan = (curpan + s * curpan) / (s + 1);
  163.  
  164. // calculating the actual volumes
  165.  
  166.     abspan = abs(curpan);
  167.     dominantpandb = 6 * abspan / 100;
  168.     dominantpan = exp((dominantpandb / 6) * log2);
  169.     recessivepan = 2 - dominantpan;
  170.  
  171. // leveling
  172.  
  173.     curpan > 0 ? (
  174.         r = dominantpan * delaybufferr[maxdelay + delaypointer - lookahead];
  175.         x = abspan / 100 * delay;
  176.         f = x - floor(x);
  177.         c = floor(x + 1) - x;
  178.         l = recessivepan * (c * delaybufferl[maxdelay + delaypointer - floor(abspan / 100 * delay) - lookahead] + f * delaybufferl[maxdelay + delaypointer - ceil(abspan / 100 * delay) - lookahead]);
  179.     ) : (
  180.         l = dominantpan * delaybufferl[maxdelay + delaypointer - lookahead];
  181.         x = abspan / 100 * delay;
  182.         f = x - floor(x);
  183.         c = floor(x + 1) - x;
  184.         r = recessivepan * (c * delaybufferr[maxdelay + delaypointer - floor(abspan / 100 * delay) - lookahead] + f * delaybufferr[maxdelay + delaypointer - ceil(abspan / 100 * delay) - lookahead]);
  185.     );
  186.  
  187.     slider10 = curpan;
  188.     
  189. // outputting
  190.  
  191.     spl0 = l;
  192.     spl1 = r;
  193.  
  194.     delaypointer += 1;
  195.     delaypointer >= maxdelay && (delaypointer = 0);
  196.  
  197.     spls += 1;